home *** CD-ROM | disk | FTP | other *** search
/ QRZ! Ham Radio 4 / QRZ Ham Radio Callsign Database - Volume 4.iso / files / dsp / drbubtxt / 56000tar.z / 56000tar / 56000 / bench / f-56.asm < prev    next >
Assembly Source File  |  1991-11-26  |  16KB  |  372 lines
  1.         page 132,60,1,1  
  2.         opt  nomd,mex  
  3. ;*******************************************
  4. ;Motorola Austin DSP Operation  June 30,1988
  5. ;*******************************************
  6. ;DSP56000/1
  7. ;Port to Memory FFT - 1024 point
  8. ;File name: F-56.asm
  9. ;**************************************************************************
  10. ;    Maximum sample rate:  1.958 ms at 20.5 MHZ/ 1.487 ms at 27.0 MHz
  11. ;    Memory Size: Prog:  254 words ; Data:  7170 words
  12. ;       Number of clock cycles:    40144 (20072 instruction cycles)
  13. ;    Clock Frequency:    20.5MHz/27.0MHz
  14. ;    Instruction cycle time:    97.5ns /  74.1ns
  15. ;**************************************************************************
  16. ;
  17. fftreald  macro     points,data,odata,coef,ptr1,ptr2
  18. fftreald  ident     1,0   
  19. ;   
  20. ; Radix 2 Decimation in Time In-Place Fast Fourier Transform Routine   
  21. ;   
  22. ;    Real input data - normally ordered   
  23. ;        Real data in Y memory, 2 buffers: one being filled, the other one being processed
  24. ;    Complex output data - normally ordered   
  25. ;        Real data in X memory   
  26. ;        Imaginary data in Y memory   
  27. ;    Coefficient lookup table   
  28. ;        -Cosine value in X memory   
  29. ;        -Sine value in Y memory   
  30. ;   
  31. ; Macro Call - fftreald   points,data,outdata,coef,ptr1,ptr2
  32. ;   
  33. ;    points     number of points (2-32768, power of 2)   
  34. ;    data       start of data buffer   
  35. ;    outdata    output data buffer   
  36. ;    coef    start of sine/cosine table   
  37. ;    ptr1    memory location of pointer to input data block 1
  38. ;    ptr2    memory location of pointer to input data block 2
  39. ;
  40. ; Alters Data ALU Registers   
  41. ;    x1   x0   y1   y0   
  42. ;    a2   a1   a0   a   
  43. ;    b2   b1   b0   b   
  44. ;   
  45. ; Alters Address Registers   
  46. ;    r0   n0   m0   
  47. ;    r1   n1   m1   
  48. ;    r2   n2   m2
  49. ;    r3   n3   m3
  50. ;    r4   n4   m4   
  51. ;    r5   n5   m5   
  52. ;    r6   n6   m6   
  53. ;    r7   n7   m7
  54. ; Alters Program Control Registers   
  55. ;    pc   sr   
  56. ;   
  57. ; Uses 8 locations on System Stack   
  58. ;   
  59. _intdata  equ $0    ;internal data space at 0 
  60. ;
  61. ;Check r7 to see if input buffer is filled
  62. ;
  63. strt move #points,b ;input buffer length
  64. loop move r7,a      ;get input data pointer
  65.      sub  a,b       ;subtract buffer length from current input location
  66.      move x:ptr1,a  ;move input data base addres into a
  67.      cmp  a,b       ;see if equal
  68.      jne  loop      ;if not, go back
  69. ;
  70. ;    when ready, swap pointers of buffer to be loaded and buffer to be processed
  71. ;
  72.      move x:ptr1,a
  73.      move x:ptr2,b
  74.      move b,x:ptr1
  75.      move a,x:ptr2
  76. ;
  77. ;    main fft routine
  78. ;
  79.      move x:ptr2,r2         ;initialize input pointers   
  80.      move #4,n2             ;initial offset for r2
  81.      move r2,r0             ;input pointer for real passes
  82.      move (r2)+n2           ;update external input pointer for complex passes
  83.      move #points/4,n0       ;initialize input and output offsets   
  84.      move #points-1,m0       ;initialize address modifiers for modulo N   
  85.      move r0,r4               ;set up butterfly pointers in and out
  86.      move (r0)+n0              ;
  87.      move r0,r5              ;
  88.      move (r0)+n0              ;
  89.      move r0,r1              ;
  90.      move r4,r0              ;
  91.      move m0,m1              ;modulo N for remaining pointers in and out
  92.      move m0,m4              ;
  93.      move m0,m5              ;
  94. ;  
  95. ; Do first and second Radix 2 FFT passes: all have real input. First and second
  96. ; passes are combined using four-point butterflies.
  97.      move                   y:(r0)+n0,a         ;get ar  
  98.      move                   y:(r0)+n0,y1        ;get br  
  99.      move                   y:(r0)+n0,b         ;get cr  
  100.      add  a,b               y:(r0)+n0,y0        ;(ar+cr),get dr  
  101.      subl b,a                                  ;cr'=(ar-cr)  
  102.      do   n0,_twopass                          ;do all four point butterflies
  103.      tfr  y0,a      a,x:(r1)                  ;get dr,save cr'  
  104.      sub  y1,a      (r0)+                      ;ci'=(dr-br)  
  105.      tfr  y1,a              a,y:(r1)+         ;get br,save ci'  
  106.      add  y0,a              y:(r0)+n0,x1        ;(br+dr),get ar  
  107.      add  b,a               y:(r0)+n0,y1       ;ar'=(ar+cr)+(br+dr),get br  
  108.      subl a,b               a,y:(r4)+         ;br'=(ar+cr)-(br+dr),save ar'  
  109.      tfr  x1,a              b,x0 y:(r0)+n0,b    ;get ar,move br',get cr  
  110.      add  a,b               y:(r0)+n0,y0       ;(ar+cr),get dr  
  111.      subl b,a       x0,x:(r5)+                 ;cr'=(ar-cr),save br'  
  112. _twopass  
  113. ;  
  114. ; Do next real-input FFT (RFFT) passes. Each RFFT butterfly is a four-point in,
  115. ; 3-point out. The fourth point is not computed since it is later obtained by
  116. ;using the conjugate symmetry property of the RFFT.
  117. ;
  118.      move #points/8,n5                        ;spacing, for 1024 spacing=128  
  119.      do   #@cvi(@log(points)/@log(2)-2.5),_next   ;7 passes for 1024 pts  
  120.      move #data,r5                             ;point to data   
  121.      move n5,n0                                 ;same offset  
  122.      move r5,r0                                 ;ar pointer  
  123.      move (r5)+n5                               ;+1/4  
  124.      move r5,r4                                 ;br pointer  
  125.      move (r5)+n5                               ;+1/2  
  126.      move r5,r1                                 ;ci pointer  
  127.      move (r5)+n5                               ;+3/4  
  128.      move                    y:(r0)+n0,a           ;get ar  
  129.      move                    y:(r0)-n0,b           ;get br  
  130.      add  a,b                                  ;ar'=(ar+br)  
  131.      do   n0,_nextpass                          ;do for all p
  132.      subl b,a  x:(r5)+,b     b,y:(r0)+         ;br'=(ar-br),get dr,save ar'  
  133.      neg  b    a,x:(r4)+     y:(r0)+n0,a        ;ci'=-dr,save br',get ar  
  134.      move b,x0              y:(r0)-n0,b        ;move ci',get br  
  135.      add  a,b                x0,y:(r1)+         ;ar'=(ar+br),save ci'  
  136. _nextpass  
  137.      move n5,a                                 ;get bflys/pass  
  138.      lsr  a                                    ;/2  
  139.      move a1,n5                                 ;put back  
  140. _next  
  141. ;  
  142. ;    special RFFT pass: real input, (4-point). Complex output: stored in normal
  143. ;    order, 4-th output stored as complex conjugate of 3rd output.
  144. ;    
  145. ;  
  146.      move #data,r0                             ;input pointer  
  147.      move #odata,r4                            ;output pointer  
  148.      move #points/2,n4                          ;output pointer offset
  149.      move #0,m4                                 ;bit reverse output  
  150.      move                     y:(r0)+,a            ;get ar  
  151.      move                     y:(r0)+,b            ;get br  
  152.      add  a,b    x:(r0)+,x0                       ;ar'=ar+br, get cr  
  153.      move      b,x:(r4)+n4                     ;save ar'
  154.      subl b,a  x:(r0),b                       ;br'=ar-br, get dr
  155.      neg  b    b,y0           a,x:(r4)+n4        ;ci'=-dr, save dr, save br'  
  156.      move      x0,x:(r4)                      ;save cr'  
  157.      move                     b,y:(r4)+n4          ;save ci'  
  158.      move      x0,x:(r4)                      ;save cr'  
  159.      move                      y0,y:(r4)+n4         ;save cr,ci'*  
  160. ; 
  161. ;    do first 2-point complex fft with conjugate storage 
  162. ;    initialization 
  163.      move      r2,r0              ;r0 points to external data 
  164.      move      #-1,m2             ;linear addr. for external input data pointer 
  165.      move      #4,n2              ;offset for external input data pointer 
  166.      move      #points/8,r3       ;coefficient base offset -->r3 
  167.      move      (r2)+n2            ;update external input data pointer 
  168.      lua       (r0)+,r1           ;initialize input pointer b 
  169.      lua       (r3)+n3,r6         ;initialize twiddle factor pointer 
  170.      move      #points/4,n4       ;offset for output counter a 
  171.      move      r4,n3              ;initialization of conjugate pointer 
  172.      move      #odata+points,r3    ; 
  173.      move      r4,r5               ;initialize output pointer b 
  174.      move      (r3)-n3             ;initialize conjugate pointer 
  175.      move      #odata,n3           ; 
  176.      lua       (r4)+n4,r5          ;initialize output pointer b 
  177.      move      (r3)+n3             ;initialize conjugate pointer 
  178.      move      n4,n5               ;initialize offset for output pointer b 
  179.      move      #0,m4               ;bit-reversed addressing for output ptr a 
  180.      move      (r5)+n5             ;initialize output pointer b 
  181.      move      #0,m5               ;bit-reversed addressing for output ptr b 
  182.      move      #0,m3               ;bit-reversed addressing for conjug. ptr. 
  183.      move      #points/2,n3        ;offset for conjugate pointer 
  184.      move                y:(r0),b  ;initialize butterfly 
  185.      move      (r3)+n3             ;future output pointer a 
  186.      move      r3,ssh              ;save future output pointer a -->stack 
  187.      move      (r3)-n3             ;reinit. conjugate pointer 
  188. ;
  189. ;    butterfly with conjugate storage    
  190. ;
  191.      move           x:(r1),x1 y:(r6),y0  
  192.      mac  x1,y0,b   x:(r6),x0 y:(r1),y1 
  193.      macr -x0,y1,b            y:(r0),a 
  194.      neg  b                   b,y:(r4)        
  195.      move                     b,y:(r3)-n3 
  196.      addl b,a       x:(r0),b   
  197.      neg  a                   a,y:(r5) 
  198.      move                     a,y:(r3)+n3 
  199.      mac  -x1,x0,b  x:(r0),a   
  200.      macr -y1,y0,b   
  201.      subl b,a       b,x:(r4)+n4 
  202.      move           b,x:(r3)-n3 
  203.      move           a,x:(r5)+n5 
  204.      move           a,x:(r3)-n3               
  205. ;    end of butterfly 
  206. ;
  207. ;    initialize pointers for complex fft's
  208. ;
  209.      move      #coef,n3  ;initialize coefficient base 
  210.      move      #-1,m3 
  211.      move      m3,m4     ;output pointer a has linear addr. 
  212.      move      m3,m5     ;output pointer b has linear addr. 
  213.      move      ssh,r4    ;initialize next external output pointer a position     
  214.      move      #2,m2     ;initialize butterflies per group 
  215.      move      #1,n4     ;initialize number of passes-1 per FFT 
  216. ;
  217. ;    do all the complex fft's that are necessary (up to N/4-point)
  218. ;
  219.      do   #@cvi(@log(points)/@log(2)-2.5),_end_fft     ;7 for 1024 pt (4- pt....256- pt)  
  220. ;
  221. ;    initialize pointers in each fft
  222.      move      r4,ssh    ;push output data address onto stack 
  223.      move r2,r0          ;get external data input address for first pass 
  224.      move #points/8,r3   ;update coefficient offset 
  225.      move m2,n1          ;initialize butterflies per group 
  226.      move #1,n2          ;initialize groups per pass 
  227. ; 
  228. ;    complex fft passes are triple nested do-loops, with last pass split out 
  229.      do   n4,_end_pass   ;do all passes but last in this fft 
  230. ;
  231. ;    initialize pointers in each pass
  232.      move n4,ssh         ;put number of passes-1 in FFT on stack 
  233.      move #_intdata,r4   ;initialize A output pointer 
  234.      move n1,r5 
  235.      move n1,n0          ;initialize pointer offsets 
  236.      lua  (r5)-,n7 
  237.      move n1,n4 
  238.      move n1,r6 
  239.      lua  (r0)+n0,r1     ;initialize B input pointer 
  240.      lua  (r4)+n4,r5     ;initialize B output pointer 
  241.      lua  (r6)+,n4 
  242.      move n4,n5 
  243.      lua  (r3)+n3,r6     ;initialize W input pointer 
  244.      move n4,n0 
  245. ;    
  246. ;    initialize butterfly input
  247.      move         x:(r1),x1     y:(r6),y0        ;lookup -sine value 
  248.      move                       y:(r0),b         ;imag. input a
  249.      mac  x1,y0,b   x:(r6)+n6,x0   y:(r1)+,y1     ;cos., imag. input b
  250.      macr -x0,y1,b                y:(r0),a       ;
  251. ;
  252. ;    butterflies
  253.      do   n2,_end_grp                        ;do for all groups                         
  254.      do   n7,_end_bfy                         ;do every butterfly in this group
  255.      subl b,a       x:(r0),b      b,y:(r4)
  256.      mac  -x1,x0,b  x:(r0)+,a     a,y:(r5)
  257.      macr -y1,y0,b  x:(r1),x1
  258.      subl b,a       b,x:(r4)+     y:(r0),b
  259.      mac  x1,y0,b                  y:(r1)+,y1     ;Radix 2 DIT butterfly kernel
  260.      macr -x0,y1,b  a,x:(r5)+     y:(r0),a      ;with constant twiddle factor
  261. _end_bfy             
  262.      move (r1)+n1
  263.      subl b,a       x:(r0),b      b,y:(r4)
  264.      mac  -x1,x0,b  x:(r0)+n0,a    a,y:(r5)
  265.      macr -y1,y0,b  x:(r1),x1     y:(r6),y0      ;lookup -sine value
  266.      subl b,a       b,x:(r4)+n4    y:(r0),b
  267.      mac  x1,y0,b   x:(r6)+n6,x0   y:(r1)+,y1
  268.      macr -x0,y1,b  a,x:(r5)+n5    y:(r0),a      ;with constant twiddle factor
  269. _end_grp            
  270.      move n1,b1
  271.      lsr  b    n2,a1                         ;divide butterflies per group by two
  272.      lsl  a    b1,n1                         ;multiply groups per pass by two
  273.      move      r3,b1
  274.      move      ssh,n4                        ;get number of passes-1 back from stack
  275.      lsr  b    a1,n2                         ;divide coefficient offset by two
  276.      move      b1,r3
  277.      move      #_intdata,r0                   ;intermediate passes use internal input data
  278. _end_pass
  279. ;        
  280. ; Do last FFT pass and move output data off-chip to external data memory.
  281. ; The output data is stored in normal order. At the same time, data is stored for
  282. ; the next output block using conjugate properties and a "reverse counter"
  283. ;
  284. ;    initialize pointers
  285.      move n7,r1
  286.      move ssh,r4
  287.      move (r1)+
  288.      move n4,ssh                    ;put #passes-1 in this fft back on stack
  289.      move r1,n0
  290.      move r1,n1                        ;correct pointer offset for last pass
  291.      move r1,n4
  292.      move r1,n5
  293.      move #points/4,n4                  ;offset for output pointer A 
  294.      lua  (r0)+,r1                  ;initialize B input pointer        
  295.      lua  (r4)+n4,r5                 ;initialize B output pointer, first step
  296.      move  n4,n5                          ;offset for output pointer B 
  297.      lua  (r3)+n3,r6                 ;initialize W input pointer
  298.      move (r5)+n5                        ;initialize B output pointer, second step
  299.      move #0,m4                         ;bit-reversed addressing for output pointer A
  300.      move r4,n3                       ;initialization of conjugate pointer
  301.      move #odata+points,r3            
  302. ;
  303. ;    initialize butterfly
  304.      move                    y:(r0),b          ;initialization of first butterfly
  305.      move      (r3)-n3                         ;initialization of conjugate pointer    
  306.      move      #odata,n3                       ;
  307.      move      x:(r1),x1     y:(r6),y0         ;initialization of first butterfly
  308.      move      (r3)+n3                         ;initialization of conjugate pointer
  309.      move      #0,m3                           ;bit-reversed addressing for conjugate ptr
  310.      move      #points/2,n3                    ;correct offset for conjugate pointer
  311.      move      m4,m5                           ;bit-reversed addressing for output pointer B     
  312.      move      (r3)+n3
  313.      move      r3,ssh                           ;put next output ptr a initialization on stack
  314.      move      (r3)-n3                         ;reset conjugate pointer
  315. ;
  316. ;    final butterfly with conjugate reverse storage of next block
  317.      do   n2,_lastpass
  318.      mac  x1,y0,b   x:(r6)+n6,x0   y:(r1)+n1,y1   ;Radix 2 DIT butterfly kernel
  319.      macr -x0,y1,b                 y:(r0),a       ;with one butterfly per group                     
  320.      neg b                         b,y:(r4)       ;and changing twiddle factor
  321.      move                          b,y:(r3)-n3    ;with conjugate storage
  322.      addl b,a  x:(r0),b  
  323.      neg a                         a,y:(r5)
  324.      move                          a,y:(r3)+n3
  325.      mac  -x1,x0,b  x:(r0)+n0,a    
  326.      macr -y1,y0,b  x:(r1),x1      y:(r6),y0
  327.      move           b,x:(r4)+n4
  328.      subl b,a       b,x:(r3)-n3    
  329.      move           a,x:(r5)+n5    y:(r0),b
  330.      move           a,x:(r3)-n3
  331. _lastpass
  332. ;
  333. ;    update pointers
  334.      move ssh,r4        ;get updated output ptr a from stck for next fft
  335.      move #coef,n3      ;n3 points to coeff. base address again
  336.      move #-1,m3        ;linear addressing for r3 again
  337.      move n6,n2          ;get fft data input offset
  338.      move m2,a           ;initial data offset-->a
  339.      move ssh,r6        ;get #passes in FFT-1 back from stack
  340.      lsl  a              ;initial data offset * 2 -->a
  341.      move #-1,m6        ;r6 increments linearly in next instruction
  342.      move #-1,m2        ;external data pointer uses linear addressing
  343.      lua (r6)+,n4          ;increment #passes-1 -->n4
  344.      move #0,m6         ;r6 increments bit-reversed again
  345.      move a1,r6         ;new initial data offset-->r6
  346.      lsl a                 ;2*#points in this fft -->a
  347.      move a1,n2         ;offset for new external input data
  348.      move m0,m4         ;initialize output pointers again for modulo addr.
  349.      move m0,m5         ;
  350.      move (r2)+n2       ;point to next complex fft input data block
  351.      move      r6,m2     ;new initial data offset for next FFT-->m2
  352. _end_fft
  353. ;
  354. ;    when fft is finished, jump back to see if data collection for next fft is completed
  355.      jmp  strt           
  356.      endm
  357. ;
  358. ;
  359. ;
  360.      org p:$8
  361.      movep     y:$ffff,y:(r7)+        ;data collection upon interrupt
  362.      org p:$100
  363.      move #256,a                    ;store pointer to data block 1
  364.      move a,x:3328
  365.      move #1280,a                    ;store pointer to data block 2
  366.      move a,x:3329
  367.      move #2047,m7                       ;set r7 for modulo addressing
  368. ;
  369. ;    call fft macro
  370.      fftreald 1024,256,2304,3330,3328,3329
  371.                                                                                                     
  372.